<?xml version="1.0"?>
<doc>
    <assembly>
        <name>EQATEC.Analytics.Monitor</name>
    </assembly>
    <members>
        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitor">
            <summary>
            Implementing class for IAnalyticsMonitor. Coordinates the interaction between
            the messaging subsystem, the statistics and the storage
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor">
            <summary>
            The main interface for the analytics monitor which can be obtained with a call to 
            <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(System.String)"/> or <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(EQATEC.Analytics.Monitor.AnalyticsMonitorSettings)"/>. The monitor will not collect data before
            a call to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/> has been performed.
            </summary>
            <remarks>For more on the features of the EQATEC Analytics service please
            refer to the <a href="http://eqatec.com/analytics">EQATEC Analytics website</a></remarks>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start">
            <summary>
            Call to start the monitor. When started the monitor will begin collecting data from the
            calls and send them asynchronously to the EQATEC Analytics servers on background threads
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception)">
            <summary>
            Call to track an exception that occured in the application.
            </summary>
            <param name="exception">the exception to be tracked</param>
            <example>An example of tracking an exception
            <code>
            static class Program 
            {   
              [STAThread]
              static void Main()
              {
                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create("YOUR-PRODUCT_KEY");
                monitor.Start();
                try 
                {
                   // your application logic here
                }
                catch(Exception exc)
                {
                  // catch-all handle 
                  monitor.TrackException(exc);
                }
                finally
                {
                  monitor.Stop();
                }
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String)">
            <summary>
            Call to track an exception that occured in the application.
            </summary>
            <param name="exception">The exception to be tracked</param>
            <param name="contextMessage">Contextual information about the action being performed when the exception occurred</param>
            <example>An example of tracking an exception
            <code>
            static class Program 
            {   
              [STAThread]
              static void Main(string[] args)
              {
                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create("YOUR-PRODUCT_KEY");
                monitor.Start();
                try 
                {
                   // your application logic here
                }
                catch(Exception exc)
                {
                  // catch-all handle 
                  monitor.TrackException(exc, "CatchAllHandler");
                }
                finally
                {
                  monitor.Stop();
                }
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String,System.Object[])">
            <summary>
            Call to track an exception that occured in the application.
            </summary>
            <param name="exception">The exception to be tracked</param>
            <param name="contextMessage">A context message string containing the information about the action being performed when the exception occurred</param>
            <param name="args">An object array containing zero or more objects to format the <paramref name="contextMessage"/></param>
            <example>An example of tracking an exception
            <code>
            static class Program 
            {   
              [STAThread]
              static void Main(string[] args)
              {
                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create("YOUR-PRODUCT_KEY");
                monitor.Start();
                try 
                {
                   // your application logic here
                }
                catch(Exception exc)
                {
                  // catch-all handle 
                  monitor.TrackException(exc, "CatchAllHandler with argument count {0}", args.Length);
                }
                finally
                {
                  monitor.Stop();
                }
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)">
            <summary>
            Register a feature usage. It is recommended that related features are grouped by using simple dot-notation
            in the <paramref name="featureName"/> such as e.g. relating print to pdf and print to file by naming the
            features "print.pdf" and "print.file" respectively
            </summary>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
            <example>The following shows an example of how you can track features in your application
            <code>
            static class Program 
            {   
              [STAThread]
              static void Main(string[] args)
              {
                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create("YOUR-PRODUCT_KEY");
                monitor.Start();
                try 
                {
                   bool exportToFile = ShouldExportToFile(); //omitted for brevity
                   if (exportToFile)
                     monitor.TrackFeature("export.file")
                }
                finally
                {
                  monitor.Stop();
                }
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)">
            <summary>
            Register the start of a feature usage. Use this with <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> to track
            how long a feature is used.
            </summary>
            <remarks>There cannot be more then one feature timing running with a given <paramref name="featureName"/> at a time.
            This implies that calling this method multiple times with the same <paramref name="featureName"/> has no effect
            until the existing time has termined by either calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> or 
            <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)"/> with the same <paramref name="featureName"/>. All features timings
            are implicitly stopped by calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop"/>.</remarks>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
            <example>The following shows an example of how you can track feature time in your application
            <code>
            class SomeClass
            {   
              private IAnalyticsMonitor m_monitor;
              public SomeClass(IAnalyticsMonitor monitor)
              {
                m_monitor = monitor;
              }
              public void Process()
              {
                try 
                {
                   m_monitor.TrackFeatureStart("SomeClass.Process");
            
                   //some process logic to time
            
                   m_monitor.TrackFeatureStop("SomeClass.Process");
                }
                catch(Exception exc)
                {
                  m_monitor.TrackFeatureCancel("SomeClass.Process");
                  throw;
                }
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)">
            <summary>
            Register the end of a feature usage stared by <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/> with a similar
            <paramref name="featureName"/>.
            </summary>
            <remarks>Calling this method with a <paramref name="featureName"/> that does not match an already
            started feature timing has no effect. All features timings
            are implicitly stopped by calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop"/>.
            </remarks>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
            <example>The following shows an example of how you can track feature time in your application
            <code>
            class SomeClass
            {   
              private IAnalyticsMonitor m_monitor;
              public SomeClass(IAnalyticsMonitor monitor)
              {
                m_monitor = monitor;
              }
              public void Process()
              {
                try 
                {
                   m_monitor.TrackFeatureStart("SomeClass.Process");
            
                   //some process logic to time
            
                   m_monitor.TrackFeatureStop("SomeClass.Process");
                }
                catch(Exception exc)
                {
                  m_monitor.TrackFeatureCancel("SomeClass.Process");
                  throw;
                }
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)">
            <summary>
            Stops an ongoing timing of a feature from any previous call to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/> with similar
            <paramref name="featureName"/> without
            registering the time spent. Use this call if the feature being tracked did not complete as expected, e.g.
            was interupted by an exception. The call can safely be made even if no <c>TrackFeatureStart</c> has
            been made.
            </summary>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
            <example>The following shows an example of how you can track feature time in your application
            <code>
            class SomeClass
            {   
              private IAnalyticsMonitor m_monitor;
              public SomeClass(IAnalyticsMonitor monitor)
              {
                m_monitor = monitor;
              }
              public void Process()
              {
                try 
                {
                   m_monitor.TrackFeatureStart("SomeClass.Process");
            
                   //some process logic to time
            
                   m_monitor.TrackFeatureStop("SomeClass.Process");
                }
                catch(Exception exc)
                {
                  m_monitor.TrackFeatureCancel("SomeClass.Process");
                  throw;
                }
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureValue(System.String,System.Int64)">
            <summary>
            Register a value on a specific feature. 
            </summary>
            <remarks>While calls to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/> increments the use of a feature in the session a call to
            this methods will associate a given value with a named feature. Use this method to e.g. track the distribution
            of file sizes imported or the number of results registered. Tracking this distribution across all your application
            usage will give insights to what scenarios your applications are handling</remarks>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
            <param name="trackedValue">The value to track</param>
            <example>The following shows an example of how you can track feature values in your application
            <code>
            class SomeClass
            {   
              private IAnalyticsMonitor m_monitor;
              public SomeClass(IAnalyticsMonitor monitor)
              {
                m_monitor = monitor;
              }
              public void Process()
              {
                int filesProcessed = ProcessFiles();
                m_monitor.TrackFeatureValue("SomeClass.FilesProcessed", filesProcessed);
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SendLog(System.String)">
            <summary>
            Send a simple log message.
            </summary>
            <remarks>Use this method to notify the servers of e.g. special conditions that occur in your
            application that needs more attention than a tracking of a feature but is not an exception
            occuring in your application. Note that there are limitations to the allowed length of the
            log message (see <see cref="P:EQATEC.Analytics.Monitor.Capabilities.MaxLengthOfLogMessage"/>) and messages longer than
            this limitation will be truncated.</remarks>
            <param name="logMessage">The log message to send to the server</param>
            <example>The following shows an example of how you can send simple log messages in your application
            <code>
            class SomeClass
            {   
              private IAnalyticsMonitor m_monitor;
              public SomeClass(IAnalyticsMonitor monitor)
              {
                m_monitor = monitor;
              }
              public void Process()
              {
                bool systemClockIsIncorrect = CheckSystemClock();
                if (systemClockIsIncorrect)
                  m_monitor.SendLog("System clock is incorrect and should be corrected");
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SendLog(System.String,System.Object[])">
            <summary>
            Send a simple log message.
            </summary>
            <remarks>Use this method to notify the servers of e.g. special conditions that occur in your
            application that needs more attention than a tracking of a feature but is not an exception
            occuring in your application. Note that there are limitations to the allowed length of the
            log message (see <see cref="P:EQATEC.Analytics.Monitor.Capabilities.MaxLengthOfLogMessage"/>) and messages longer than
            this limitation will be truncated.</remarks>
            <param name="messageFormat">The log message to send to the server</param>
            <param name="args">Arguments to the message format</param>
            <example>The following shows an example of how you can send simple log messages in your application
            <code>
            class SomeClass
            {   
              private IAnalyticsMonitor m_monitor;
              public SomeClass(IAnalyticsMonitor monitor)
              {
                m_monitor = monitor;
              }
              public void Process()
              {
                bool systemClockIsIncorrect = CheckSystemClock();
                if (systemClockIsIncorrect)
                  m_monitor.SendLog("System clock is incorrect and should be corrected: {0}", GetSystemClock());
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SendLog(System.String,System.Byte[],System.String)">
            <summary>
            Send a simple log message along with binary data and an optional mime type.
            </summary>
            <remarks>Use this method to associate some binary data with the simple log message. There are
            some limitations both to the allowed length of the log message (see <see cref="P:EQATEC.Analytics.Monitor.Capabilities.MaxLengthOfLogMessage"/>) as
            well as the size of the log data (see <see cref="P:EQATEC.Analytics.Monitor.Capabilities.MaxLogFileDataSizeInKB"/>) and the
            length of the mime type (see <see cref="P:EQATEC.Analytics.Monitor.Capabilities.MaxLogFileMimeTypeLength"/>). It should also be noted
            that the monitor has some internal limitations preventing to much data from being queued up.</remarks>
            <param name="logMessage">The log message to send to the server.</param>
            <param name="data">The raw data to send to the server along with the log message.</param>
            <param name="mimeType">The optional mimetype of the binary data for more effecient server side handling</param>
            <example>The following shows an example of how you can send a log message with binary data associated
            <code>
            class SomeClass
            {   
              private IAnalyticsMonitor m_monitor;
              public SomeClass(IAnalyticsMonitor monitor)
              {
                m_monitor = monitor;
              }
              public void Process()
              {
                bool calibrationDataIsInvalid = CheckCalibrationData();
                if (calibrationDataIsInvalid)
                  m_monitor.SendLog("CalibrationData is invalid", GetCalibrationData(), "text/plain");
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop">
            <summary>
            Call to stop the monitor. Call will attempt to save any pending state
            to the storage and send the final tracking data to the servers. 
            </summary>
            <remarks>Note that this call will attempt to send the final tracking data to the servers and
            is designed to block for up to 2 seconds in order to deliver the data and receive confirmation back. Having
            this method block for a short while has been donoe intentionally since the call to this method is typically performed
            during application shutdown and if this method did not block to allow proper data delivery there is an increased
            possibility that the runtime and threadpools will be terminated before a reply is received on the background
            threads.</remarks>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync">
            <summary>
            Explicitly force a synchonization of the current information with the analytics server. 
            </summary>
            <remarks>This call is not expected to be used in a standard setup but may be helpful in occasionally connected 
            scenarios. You can use this method in conjunction with setting <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.SynchronizeAutomatically"/> to <c>false</c>
            in order to take control of when data is attempted to be delivered to the servers. By default the monitor will
            control the data delivery internally but if you need to decide e.g. when networks can be utilized you
            can use this method to schedule an asynchronous data delivery
            </remarks>
            <seealso cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)">
            <summary>
            Associates an installation ID with the current session and returns an <see cref="T:EQATEC.Analytics.Monitor.IInstallationSettings"/> instance
            which can be used to dynamically alter installation settings on the monitor.
            </summary>
            <remarks>Use this method to register you installationid on the monitor and optionally associate
            installation properties with this installation id. You can call this method multiple times
            while the monitor is running and thus alter the installation id associated with the session at runtime. Note however
            that changing the installation id will also reset any previous installation properties associated with the previous 
            installation id from the session so you will need to associate them again</remarks>
            <param name="installationId">The installation ID to associate with the current session</param>
            <returns>an <see cref="T:EQATEC.Analytics.Monitor.IInstallationSettings"/> instance to be used for for installation property registration</returns>
            <seealso cref="T:EQATEC.Analytics.Monitor.IInstallationSettings"/>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Lookup(System.String,System.Action{EQATEC.Analytics.Monitor.LookupReply})">
            <summary>
            Performs an asynchronous key-based lookup on the server and returns the responding value from
            the server on the callback argument. 
            </summary>
            <remarks>You can utilize token replacements in the <paramref name="lookupKey"/> which allows the 
            lookups configured on the servers to take advantedge of information from the monitor. The tokens that are supported
            are {cookieid}, {version} and {installationid} (case sensitive)</remarks>
            <param name="lookupKey">the key to perform the lookup with</param>
            <param name="callback">the callback for the value of the lookup</param>
            <example>The following shows an example of how you can utilize a lookup in your application
            <code>
            class BetaVersionCheck
            {   
              private IAnalyticsMonitor m_monitor;
              public event EventHandler IsBeta = delegate {};
              public BetaVersionCheck(IAnalyticsMonitor monitor)
              {
                m_monitor = monitor;
              }
              public void IsBeta()
              {
                m_monitor.Lookup("isbeta.{version}", 
                                (reply) => {
                                             if (reply.KeyWasMatched)
                                                if (reply.Value == "BETA")
                                                  IsBeta(this, EventArgs.Empty);
                                           });
              } 
            }
            </code>
            </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Lookup(System.String,System.TimeSpan,System.Action{EQATEC.Analytics.Monitor.LookupReply})">
            <summary>
            Performs an asynchronous key-based lookup on the server with a specific timeout and returns the responding value from
            the server on the callback argument. 
            </summary>
            <remarks>You can utilize token replacements in the <paramref name="lookupKey"/> which allows the 
            lookups configured on the servers to take advantedge of information from the monitor. The tokens that are supported
            are <value>{cookieid}</value>, <value>{version}</value> and <value>{installationid}</value> (case sensitive)</remarks>
            <param name="lookupKey">the key to perform the lookup with</param>
            <param name="timeout">the timeout before abandoning the lookup and returning the callback. Use TimeSpan.Zero for infinite timeout</param>
            <param name="callback">the callback for the value of the lookup</param>
            <example>The following shows an example of how you can utilize a lookup in your application
            <code>
            class BetaVersionCheck
            {   
              private IAnalyticsMonitor m_monitor;
              public event EventHandler IsBeta = delegate {};
              public BetaVersionCheck(IAnalyticsMonitor monitor)
              {
                m_monitor = monitor;
              }
              public void IsBeta()
              {
                m_monitor.Lookup("isbeta.{version}", 
                                 TimeSpan.FromSeconds(10),
                                (reply) => {
                                             if (reply.IsTimedOut)
                                               IsBeta(this, EventArgs.Empty); //...or some other logic
            
                                             if (reply.KeyWasMatched)
                                                if (reply.Value == "BETA")
                                                  IsBeta(this, EventArgs.Empty);
                                           });
              } 
            }
            </code>
            </example>
        </member>
        <member name="E:EQATEC.Analytics.Monitor.IAnalyticsMonitor.VersionAvailable">
             <summary>
             Event raised if the monitor receives information on a newer product version from the
             servers. The event is only raised once for each version.
             </summary>
             <see cref="T:EQATEC.Analytics.Monitor.VersionAvailableEventArgs"/>
             <example> This sample shows how to use the version check.
             <code>
             class MyClass 
             {
               static void Main() 
               {
                 //Creating IAnalyticsMonitor
                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create("YOUR_PRODUCT_KEY_HERE");
             
                 //Hookup version check handler
                 monitor.VersionAvailable += new EventHandler&lt;VersionAvailableEventArgs&gt;(monitor_VersionAvailable);
            
                 //Start Analytics monitor
                 monitor.Start();
            
                 /*Your program here....*/
                 
                 //Stop Analytics monitor
                 monitor.Stop();
               }
               static void monitor_VersionAvailable(object sender, VersionAvailableEventArgs e)
               {
                 MessageBox.Show("Version " + e.OfficialVersion + " is available. Download here: " + e.DownloadUri);
               }
             }
             </code>
             </example>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Capabilities">
            <summary>
            Get the capabilities of the current analytics monitor. The <see cref="P:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Capabilities"/> instance
            will allow callers to adjust certain call parameters to not violate the limitations
            of the current monitor.
            </summary>
            <seealso cref="P:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Capabilities"/>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.IInstallationSettings">
            <summary>
             Representing the settings associated with a given installation ID for a session. Can be obtained
             by a call to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)"/>
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IInstallationSettings.SetInstallationProperties(System.Collections.Generic.Dictionary{System.String,System.String})">
            <summary>
             Associate the dictionary of key-value pairs with the current installation settings
            </summary>
             <param name="installationProperties">dictionary of key-value pairs to associate with the installation</param>
             <returns>The result of the action to set the installation properties. If return value is <see langword="false"/>, a error description are logged in <see cref="T:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor"/></returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.#ctor(EQATEC.Analytics.Monitor.IStatisticsMonitor,EQATEC.Analytics.Monitor.ILogAnalyticsMonitor,EQATEC.Analytics.Monitor.Policy.MonitorPolicy)">
            <summary>
            Constructor
            </summary>
            <param name="statisticsMonitor">the statistics monitor</param>
            <param name="log">the logging interface</param>
            <param name="policy">the internal settings object</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Start">
            <summary>
            Initializes the monitor
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.SendLog(System.String)">
            <summary>
            Send log message
            </summary>
            <param name="logMessage"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.SendLog(System.String,System.Object[])">
            <summary>
            Send log message
            </summary>
            <param name="logMessage"></param>
            <param name="args"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.SendLog(System.String,System.Byte[],System.String)">
            <summary>
            Send log message with file data
            </summary>
            <param name="logMessage"></param>
            <param name="data"></param>
            <param name="mimetype"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackException(System.Exception)">
            <summary>
            Track exception
            </summary>
            <param name="exception"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackException(System.Exception,System.String)">
            <summary>
            Track exception
            </summary>
            <param name="exception"></param>
            <param name="contextMessage"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackException(System.Exception,System.String,System.Object[])">
            <summary>
            Track exception
            </summary>
            <param name="exception"></param>
            <param name="contextMessage"></param>
            <param name="args"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeature(System.String)">
            <summary>
            Regsiter a feature usage. Features can be structured in a hieracy using dot-notation.
            For example use "export" to track all export operations as one, or use "export.html"
            and "export.pdf" to track exports to html and pdf seperately such that they can be compared.<br/>
            Do not, however, use freeform text, such as the name of file being exported to, as the featureName.
            </summary>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeatureStart(System.String)">
            <summary>
            Tracking a feature start
            </summary>
            <param name="featureName"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeatureStop(System.String)">
            <summary>
            Tracking a feature stop
            </summary>
            <param name="featureName"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeatureCancel(System.String)">
            <summary>
            Cancelling a feature timing
            </summary>
            <param name="featureName"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.ForceSync">
            <summary>
            Force a synchonization the current information with the analytics server.
            This should not be used in normal situations.
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.SetInstallationInfo(System.String)">
            <summary>
            Set installationId at the current session and get interface to installation settings
            </summary>
            <param name="installationId"></param>
            <returns></returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Lookup(System.String,System.Action{EQATEC.Analytics.Monitor.LookupReply})">
            <summary>
            Performs an asynchronous key-based lookup on the server and returns the responding value from
            the server on the callback argument. If the server has no corresponding value for the given key
            the responding value is null
            </summary>
            <param name="lookupKey">the key to perform the lookup with</param>
            <param name="callback">the callback for the value of the lookup</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Lookup(System.String,System.TimeSpan,System.Action{EQATEC.Analytics.Monitor.LookupReply})">
            <summary>
            Performs an asynchronous key-based lookup on the server and returns the responding value from
            the server on the callback argument. If the server has no corresponding value for the given key
            the responding value is null
            </summary>
            <param name="lookupKey">the key to perform the lookup with</param>
            <param name="timeout">the timeout period to wait for the asynchronous server reply</param>
            <param name="callback">the callback for the value of the lookup</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Stop">
            <summary>
            Stop the Analytics monitor. Will attempt to write any pending
            state to the storage
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Stop(System.Int32)">
            <summary>
            Stop the Analytics monitor. Will attempt to write any pending
            state to the storage
            </summary>
            <param name="timeout">The timeout in milliseconds for any server communication in progress</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.System#IDisposable#Dispose">
            <summary>
            Dispose the monitor
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitor.Capabilities">
            <summary>
            Get the capabilities of the current analytics monitor. The <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitor.Capabilities"/> instance
            will allow callers to adjust certain call parameters to not violate the limitations
            of the current monitor.
            </summary>
        </member>
        <member name="E:EQATEC.Analytics.Monitor.AnalyticsMonitor.VersionAvailable">
            <summary>
            Event raised when a version check has ended, succesfully or not
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade">
             <summary>
             Represents a simple facade for interacting with the Analytics Monitor. Use this facade interface instead
             of interacting more directly with the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory"/> and <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/>
             interfaces for a slightly higher level interaction model.
             </summary>
             <remarks>
             The facade will instantiate a single <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance on the Create call and
             the remaining methods on this class mirror the methods found on the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface. The
             facade can be used by consumers as a simple way of calling the API without worrying about passing the
             <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance around and about the timing issues of when the methods can be 
             called. The facade will encapsulate the created instance, raise an exception for multiple calls
             to the <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(System.String)"/> methods and will forward the methods on to the instance when it is available.
             
             If the facade represent too high level control or you would like to control the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/>
             instance yourself you should look at using the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory"/> methods.
             
             Repeated calls to the Create methods will raise exceptions as the intended use of the facade is for simple integration scenarios</remarks>
             <example> This sample shows how to use AnalyticsMonitorFacade.
             <code>
             class MyClass 
             {
               static void Main()
               {
                 //Creating Analytics Monitor
                 AnalyticsMonitorFacade.Create("YOUR_PRODUCT_KEY_HERE");
            
                 //Start Analytics monitor
                 AnalyticsMonitorFacade.Start();
            
                 /*Your program here....*/
            
                 //Stop Analytics monitor
                 AnalyticsMonitorFacade.Stop();
               }
             }
             </code>
             </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(System.String)">
            <summary>
            Initializes the facade by creating a monitor with the given product id and the standard
            settings
            </summary>
            <param name="productId">the product id to use</param>
            <exception cref="T:System.InvalidOperationException">if Create has already been called</exception>
            <exception cref="T:System.ArgumentException">if the product id is not correctly formatted</exception>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(EQATEC.Analytics.Monitor.AnalyticsMonitorSettings)">
            <summary>
            Initializes the facade by creating a monitor with the specified
            settings
            </summary>
            <param name="settings">the product id to use</param>
            <exception cref="T:System.InvalidOperationException">if Create has already been called</exception>
            <exception cref="T:System.ArgumentNullException">if null is passed as settings</exception>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(EQATEC.Analytics.Monitor.IAnalyticsMonitor)">
            <summary>
            Internal method for creating the facade
            </summary>
            <param name="instance"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Start">
            <summary>
            Start the monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/> method
            </summary>
            <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Stop">
            <summary>
            Stop the monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop"/> method
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackException(System.Exception)">
            <summary>
            Track an exception. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception)"/> method
            </summary>
            <param name="exception">the exception instance</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackException(System.Exception,System.String)">
            <summary>
            Track an exception along with a context message. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String)"/> method
            </summary>
            <param name="exception">the exception instance</param>
            <param name="message">an additional context message specifying extra information not captured in the exception</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackException(System.Exception,System.String,System.Object[])">
            <summary>
            Track an exception with a formatted context message. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String,System.Object[])"/> method
            </summary>
            <param name="exception">the exception instance</param>
            <param name="format">a format string for specifying extra information not captured in the exception</param>
            <param name="args">arguments to the format string</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeature(System.String)">
            <summary>
            Register a feature usage. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/> method
            </summary>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureStart(System.String)">
            <summary>
            Register the start of a feature usage. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/> method
            </summary>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureStop(System.String)">
            <summary>
            Register the end of a feature usage stared by <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureStart(System.String)"/>.Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> method
            </summary>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureCancel(System.String)">
            <summary>
            Cancels an ongoing feature timing tracking. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)"/> method
            </summary>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureValue(System.String,System.Int64)">
            <summary>
            Tracks a value on a named feature. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureValue(System.String,System.Int64)"/> method
            </summary>
            <param name="featureName">The name of the feature. If it is null and empty the request is ignored.</param>
            <param name="value">The value to be tracked</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.SendLog(System.String)">
            <summary>
            Send a log message to the server. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SendLog(System.String)"/> method
            </summary>
            <param name="logMessage">the log message to send to the server</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.SendLog(System.String,System.Object[])">
            <summary>
            Send a log message to the server. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SendLog(System.String,System.Object[])"/> method
            </summary>
            <param name="messageFormat">the log message to send to the server</param>
            <param name="args">arguments to the message format</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.SendLog(System.String,System.Byte[],System.String)">
            <summary>
            Send a log message with associated data and mime type. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SendLog(System.String,System.Byte[],System.String)"/> method
            </summary>
            <param name="logMessage">the log message</param>
            <param name="data">the associated data</param>
            <param name="mimeType">the optional mime type</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Lookup(System.String,System.TimeSpan,System.Action{EQATEC.Analytics.Monitor.LookupReply})">
            <summary>
            Performs an async lookup on the server for the specific lookup key. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Lookup(System.String,System.TimeSpan,System.Action{EQATEC.Analytics.Monitor.LookupReply})"/> method
            </summary>
            <param name="lookupKey">the lookup key</param>
            <param name="timeout">the timeout before abandoning the lookup. Specifiy TimeSpan.Zero for no timeout</param>
            <param name="callback">the callback for the reply</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.ForceSync">
            <summary>
            Force a sync for manual synchronization. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync"/> call.
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.SetInstallationInfo(System.String)">
            <summary>
            Sets the installation id for the current monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)"/> call
            </summary>
            <param name="installationID">The current installation id to assign</param>
            <returns>The <see cref="T:EQATEC.Analytics.Monitor.IInstallationSettings"/> instance to use for further installation property assignment</returns>
        </member>
        <member name="E:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.VersionAvailable">
            <summary>
            Raised when a new version is available
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Capabilities">
            <summary>
            Get the current capabilities of the wrapped monitor
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory">
            <summary>
            Factory for creating <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instances. Call with an instance of 
            <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> to customize behavior of the constructed monitor.
            </summary>
            <remarks>While it is possible to create multiple monitors for the same product id from within
            the same application it is not encouraged as it may lead to inconsistencies in data stored on disk.</remarks>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(System.String)">
             <summary>
             Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance using the default settings
             </summary>
             <param name="productId">the product ID</param>
             <returns>an instance of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface</returns>
             <exception cref="T:System.ArgumentException">thrown if product id provided valid have the wrong format (guid format expected)</exception>
             <example> This sample shows how to start the Analytics monitor.
             <code>
             class MyClass 
             {
               static void Main() 
               {
                 //Creating IAnalyticsMonitor
                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create("YOUR_PRODUCT_KEY_HERE");
             
                 //Start Analytics monitor
                 monitor.Start();
            
                 /*Your program here....*/
                 
                 //Stop Analytics monitor
                 monitor.Stop();
               }
             }
             </code>
             </example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(EQATEC.Analytics.Monitor.AnalyticsMonitorSettings)">
             <summary>
             Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance using the customized settings in the
             <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance.
             </summary>
             <param name="analyticsMonitorSettings">the settings to use for constructing the instance</param>
             <returns>an instance of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface</returns>
             <exception cref="T:System.ArgumentNullException">thrown if product the <paramref name="analyticsMonitorSettings"/> is null</exception>
             <example> This sample shows how to start the Analytics monitor.
             <code>
             class MyClass 
             {
               static void Main() 
               {
                 //Creating AnalyticsMonitorSettings
                 AnalyticsMonitorSettings settings = new AnalyticsMonitorSettings("YOUR_PRODUCT_KEY_HERE");
                 settings.TestMode = true;
             
                 //Creating IAnalyticsMonitor
                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create(settings);
             
                 //Start Analytics monitor
                 monitor.Start();
            
                 /*Your program here....*/
                 
                 //Stop Analytics monitor
                 monitor.Stop();
               }
             }
             </code>
             </example>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Capabilities">
            <summary>
            Exposing the current capabilities of the analytics monitor instance that may influence
            how the data you pass into the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance are handled. 
            </summary>
            <remarks>Note that
            the capabilities may change at runtime after e.g. interaction with the EQATEC Analytics
            servers</remarks>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxLengthOfLogMessage">
            <summary>
            Get the maximum allowed length of a log message. Longer messages will be truncated
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxLengthOfExceptionContextMessage">
            <summary>
            Get the maximum allowed size of the context message associated with an exception in a call to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String)"/>. Longer context messages
            will be truncated
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxAllowedBandwidthUsagePerDayInKB">
            <summary>
            Get the maximum allowed bandwidth utilization for the monitor per day measured in kilobytes. This setting can be
            altered before constructing the monitor instance by using the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.DailyNetworkUtilizationInKB"/>
            property
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxLengthOfFeatureName">
            <summary>
            Get the maximum allowed length of a feature name as used in <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/>, <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/>,
            <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> or <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)"/>
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxNumberOfInstallationProperties">
            <summary>
            Get the maximum number of installation properties stored with a given installation id. You can pass in
            installation properties using <see cref="M:EQATEC.Analytics.Monitor.IInstallationSettings.SetInstallationProperties(System.Collections.Generic.Dictionary{System.String,System.String})"/>. You can
            obtain the <see cref="T:EQATEC.Analytics.Monitor.IInstallationSettings"/> instance using <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)"/>
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxKeySizeOfInstallationPropertyKey">
            <summary>
            Get the maximum size of an installation property key. Installation properties are specified using <see cref="M:EQATEC.Analytics.Monitor.IInstallationSettings.SetInstallationProperties(System.Collections.Generic.Dictionary{System.String,System.String})"/>. 
            You can obtain the <see cref="T:EQATEC.Analytics.Monitor.IInstallationSettings"/> instance using <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)"/>
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxLogFileMimeTypeLength">
            <summary>
            Get the maximum length of the mime type associated with a logfile in <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SendLog(System.String,System.Byte[],System.String)"/>.
            Longer mime types are truncated.
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxLogFileDataSizeInKB">
            <summary>
            Get the maximum size of logfile data accepted by the monitor in <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SendLog(System.String,System.Byte[],System.String)"/>. Data
            sizes above this limitation will cause the log to not be delivered to the servers.
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxLogMessageLength">
            <summary>
            Get the allowed maximum length of a log message in <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SendLog(System.String)"/>. Longer messages
            are truncated
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxStorageSizeInKB">
            <summary>
            Get the maximum size of the data written to storage from the monitor. This size altered before 
            constructing the monitor instance by using the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.MaxStorageSizeInKB"/> 
            property
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Capabilities.MaxInstallationIDSize">
            <summary>
            Get the maximum size of the installationid accepted in <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)"/>. Values
            that are too long are truncated
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.InstallationSettings">
            <summary>
            Internal stttings
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.InstallationSettings.InstallationId">
            <summary>
            Installation id
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.InstallationSettings.InstallationProperties">
            <summary>
            Installation Properties
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.LookupReply">
            <summary>
            Representing the reply for a <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Lookup(System.String,System.TimeSpan,System.Action{EQATEC.Analytics.Monitor.LookupReply})"/>. The struct represents both
            successful and unsuccessful results for a lookup operation.
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.LookupReply.Key">
            <summary>
            The requesting key
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.LookupReply.Value">
            <summary>
            The return value, if any. If the server was not contacted the value is <see langword="null"/>. If
            the server was contacted but had no matching value for the key, the value is the empty string
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.LookupReply.IsTimedOut">
            <summary>
            True if the reply is caused by a timeout
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.LookupReply.ServerWasReached">
            <summary>
            True if the server was reached
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.LookupReply.KeyWasMatched">
            <summary>
            True if the server was reached and a lookup was configured on the server that matched the key
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Model.ExceptionEntry">
            <summary>
            Holding an exception entry
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.ExceptionEntry.#ctor(System.TimeSpan,System.String,System.String,System.String,System.String,System.String,System.String,EQATEC.Analytics.Monitor.Model.ExceptionEntry)">
            <summary>
            Verbose constructor
            </summary>
            <param name="time"></param>
            <param name="extraInfo"></param>
            <param name="type"></param>
            <param name="source"></param>
            <param name="targetSite"></param>
            <param name="message"></param>
            <param name="stackTrace"></param>
            <param name="innerException"></param>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.ExceptionEntry.Time">
            <summary>
            The uptime when the exception occured
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.ExceptionEntry.ExtraInfo">
            <summary>
            Additional context information with this exception
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.ExceptionEntry.Type">
            <summary>
            The exception type
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.ExceptionEntry.Message">
            <summary>
            The exception message
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.ExceptionEntry.TargetSite">
            <summary>
            The target site, taken from the exception object
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.ExceptionEntry.Source">
            <summary>
            The source
            </summary>, taken from the exception object
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.ExceptionEntry.StackTrace">
            <summary>
            The stacktrace, taken from the exception object
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.ExceptionEntry.InnerException">
            <summary>
            The inner exception object
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Model.LogEntry">
            <summary>
            Data carrying class encapsulating a log message
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Model.ModelXmlSerializer">
            <summary>
            Serializer for the Statistics data, serialization to custom Xml format
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.ModelXmlSerializer.Serialize(System.Xml.XmlWriter,EQATEC.Analytics.Monitor.Model.Statistics,System.DateTime,System.TimeSpan,EQATEC.Analytics.Monitor.Model.SerializationTarget,EQATEC.Analytics.Monitor.Policy.MonitorPolicy,System.String[],EQATEC.Analytics.Monitor.Storage.StorageLevel)">
            <summary>
            Serialization into an XmlWriter
            </summary>
            <param name="xtw"></param>
            <param name="statistics"></param>
            <param name="time"></param>
            <param name="uptime"></param>
            <param name="target"></param>
            <param name="policy"></param>
            <param name="lookupKeys"></param>
            <param name="storageLevel"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.ModelXmlSerializer.Deserialize(System.Xml.XmlReader,System.DateTime,System.TimeSpan)">
            <summary>
            Deserialization from an XmlReader
            </summary>
            <param name="xr"></param>
            <param name="time"></param>
            <param name="uptime"></param>
            <returns></returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Model.Session">
            <summary>
            Encapsulation of a session. Root object for the all information
            happening as part of a 'usage'
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.Session.CreateSnapshot">
            <summary>
            Create a current snapshot of the session information
            </summary>
            <returns></returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.Session.ApplySnapshot(EQATEC.Analytics.Monitor.Model.Session)">
            <summary>
            Applying snapshots, hooking up session information from
            a storage to the current instance
            </summary>
            <param name="session"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Policy.PolicyXmlSerializer.Serialize(System.Xml.XmlWriter,EQATEC.Analytics.Monitor.Policy.MonitorPolicy,System.DateTime,System.TimeSpan)">
            <summary>
            Serialization into an XmlWriter
            </summary>
            <param name="xtw"></param>
            <param name="time"></param>
            <param name="uptime"></param>
            <param name="policy"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Policy.SettingsValue`1.SetExplictValue(`0)">
            <summary>
            Set the value explicitly set through the API
            </summary>
            <param name="explicitValue"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Policy.SettingsValue`1.SetValue(`0)">
            <summary>
            Setting the value, will override any explicit value 
            set by the API
            </summary>
            <param name="value"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Policy.SettingsValue`1.Reset">
            <summary>
            Reset the value, either to a default or to the explicit value
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Policy.SettingsValue`1.Default">
            <summary>
            The default value, if not overriden
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Policy.SettingsValue`1.Value">
            <summary>
            The actual current value
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Policy.SettingsValue`1.ExplicitValue">
            <summary>
            Value set by the programmer/API, may have been overriden 
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Policy.SettingsValue`1.IsExplicit">
            <summary>
            Returns whether the current value is explicit
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.ProxyConfiguration">
            <summary>
            Container for proxy configuration. Apply the proxy configuration on the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/>
            object passed into the <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(EQATEC.Analytics.Monitor.AnalyticsMonitorSettings)"/> call in order to
            have the monitor use specific proxy settings
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.ProxyConfiguration.ProxyConnectionStr">
            <summary>
            Specify a connection string for the proxy  e.g. "MyProxyServer:8080".
            </summary>
            <remarks>Default proxy functionality (taken from the underlying OS) is applied if ProxyConnectionStr
            is null or empty</remarks>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.ProxyConfiguration.ProxyUserName">
            <summary>
            Specify the user name used in the proxy connection.
            The system will connect without username/password if ProxyUserName is null or empty.
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.ProxyConfiguration.ProxyPass">
            <summary>
            Specify the password used in the proxy connection.
            The system will connect without username/password if ProxyPass is null or empty.
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor">
            <summary>
            Interface used for outputting log messages internally from
            a constructed <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance. The logging interface can be
            specified on the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> object which passed into the
            <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(EQATEC.Analytics.Monitor.AnalyticsMonitorSettings)"/> call
            </summary>
            <example>The following is an example of creating your custom logging implementation
            and hooking it up:
            <code>
            public class MyConsoleLog : ILogAnalyticsMonitor
            {
              public void LogMessage(string message)
              { 
                 System.Console.WriteLine("MESSAGE: " + message);
              }
              
              public void LogError(string error)
              {
                 System.Console.WriteLine("ERROR: " + error);
              }
            }
            
            ...
            
            AnalyticsMonitorSettings setttings = new AnalyticsMonitorSettings("PRODUCT_KEY_HERE");
            settings.LoggingInterface = new MyConsoleLog();
            IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create(settings);
            ...
            
            </code></example>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor.LogMessage(System.String)">
            <summary>
            Logging a message. This is called for informative messages
            internally in the analytics monitor. These are not error messages
            but messages on specific actions being performed
            </summary>
            <param name="message">describes the action being performed</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor.LogError(System.String)">
            <summary>
            Logging an error message. This is called when an error occurs
            internally in the analytics monitor. The errorMessage will contain
            a human readable error message describing the error
            </summary>
            <param name="errorMessage">describes the error message</param>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.IMessageFactory">
            <summary>
            Interface for building messages to send
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.IMessageFactory.BuildStatisticsMessage(EQATEC.Analytics.Monitor.Messaging.MessageContext)">
            <summary>
            Build the statistics message given a cookie, a statistics instance and
            a boolean indicating whether this is a message from a new day
            </summary>
            <param name="messageContext"></param>
            <returns></returns>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Messaging.IMessageFactory.MessageFactoryVersion">
            <summary>
            Get version of the message factory
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.MessageContext">
            <summary>
            Struct representing the information needed to construct a message
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.IMessageReceiver">
            <summary>
            Interface for handling reception of messages
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.IMessageReceiver.ParseResponse(EQATEC.Analytics.Monitor.Messaging.MessageResponse)">
            <summary>
            Receive an incoming message payload and return any message relating
            to the processing of the payload. An empty return string indicates no issues
            with the response processing
            </summary>
            <param name="serverResponse"></param>
            <returns></returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.IMessageSender">
            <summary>
            Interface for sending message payload
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.IMessageSender.SendMessage(System.Uri,System.Byte[],System.Action{EQATEC.Analytics.Monitor.Messaging.MessageResponse})">
            <summary>
            Send the message payload async and callback with the received response message on 
            the callback action
            </summary>
            <param name="baseUri"></param>
            <param name="payload"></param>
            <param name="messageResponseCallback"></param>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.IMessagingSubSystem">
            <summary>
            Internal interface for handling all messaging aspects
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.IMessagingSubSystem.WaitForIdle(System.Int32)">
            <summary>
            Internal interface primarily for allowing testing to wait for message processing
            to become idle
            </summary>
            <param name="timeoutMilliSec"></param>
            <returns></returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.IMessagingSubSystem.SendMessage(System.Byte[],System.Action{EQATEC.Analytics.Monitor.Messaging.SendMessageResult})">
            <summary>
            Send a payload and receive the response message on the callback
            </summary>
            <param name="payload"></param>
            <param name="sendingResultCallback"></param>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Messaging.IMessagingSubSystem.ActiveRequestCount">
            <summary>
            Get number of active requests at this time
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.IStatisticsMonitor">
            <summary>
            Internal statistics frontend for collecting the
            statistics information
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.IStorage">
            <summary>
            A storage interface for loading and save data for a given product ID. This inteface can be
            implementing an specified on the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance in order to better
            control where the monitor persists data.
            </summary>
            <remarks>
            Creating and utilizing a custom implementation of this interface may be relevant if you require
            special handling of where the monitor saves data. This could be relevant for e.g. embedded devices
            or for situation where there is a need to explicitly know where the data is being stored
            </remarks>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IStorage.Save(System.String,System.Byte[])">
            <summary>
            Save data for a given product ID
            </summary>
            <param name="productID">the product ID</param>
            <param name="data">the data to save</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.IStorage.Load(System.String)">
            <summary>
            Load existing data for product ID. If no data is available, implementors should
            return null or an empty array
            </summary>
            <param name="productID">the product ID</param>
            <returns>any previously persisted data or null if no data available</returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Storage.IStorageFactory">
            <summary>
            Interface encapsulating access to stored statistics and access
            data
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.MessageFactory">
            <summary>
            Message factory for coinstructing message payloads
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessageFactory.BuildStatisticsMessage(EQATEC.Analytics.Monitor.Messaging.MessageContext)">
            <summary>
            Create message for sending the current statistics to the server
            </summary>
            <param name="messageContext">The message context to send</param>
            <returns>The message to send</returns>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Messaging.MessageFactory.MessageFactoryVersion">
            <summary>
            Current version of the message factory. Is changes as message formats
            are altered over time
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.MessageReceiver">
            <summary>
            Class handling the reception and parsing of messages from server
            and for delegating information received from the server to the
            appropriate reception handler
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessageReceiver.#ctor(System.Int32,EQATEC.Analytics.Monitor.ILogAnalyticsMonitor,EQATEC.Analytics.Monitor.Policy.MonitorPolicy)">
            <summary>
            Constructor
            </summary>
            <param name="messageFactoryVersion"></param>
            <param name="log">the logging interface</param>
            <param name="policy"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessageReceiver.ParseResponse(EQATEC.Analytics.Monitor.Messaging.MessageResponse)">
            <summary>
            Handles the reception of incoming payload from the server and returns 
            the reponse processing information. An empty return value indicates processing
            without problems
            </summary>
            <param name="messageResponse">the incoming payload</param>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.MessageSender">
            <summary>
            Class handling the asynchronous sending of messages and forwarding received messages
            to the IMessageReceiver
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessageSender.#ctor(EQATEC.Analytics.Monitor.ILogAnalyticsMonitor,EQATEC.Analytics.Monitor.ProxyConfiguration,EQATEC.Analytics.Monitor.Policy.MonitorPolicy)">
            <summary>
            Constructor
            </summary>
            <param name="log">the logging interface</param>
            <param name="proxyConfig">the proxy configuration</param>
            <param name="policy">the policy configuration</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessageSender.SendMessage(System.Uri,System.Byte[],System.Action{EQATEC.Analytics.Monitor.Messaging.MessageResponse})">
            <summary>
            Send the message asynchronously and invokes the sendMessageCallback when message sending
            has succeeded or failed with the payload. If sending fails a null message is send on the 
            callback
            </summary>
            <param name="baseUri"></param>
            <param name="payload">the message to send</param>
            <param name="sendMessageCallback">the callback, called with the received payload</param>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem">
            <summary>
            Class encapsulating the messaging system in the Analytics Monitor. This
            class handles and coordinates to ensure that messages are send and retried
            and eventually failed if unable to contact server
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.#ctor(EQATEC.Analytics.Monitor.Messaging.IMessageReceiver,EQATEC.Analytics.Monitor.Messaging.IMessageSender,EQATEC.Analytics.Monitor.Policy.MonitorPolicy,System.Uri,EQATEC.Analytics.Monitor.ILogAnalyticsMonitor)">
            <summary>
            Constructor
            </summary>
            <param name="receiver"></param>
            <param name="sender"></param>
            <param name="policy"></param>
            <param name="defaultUri"></param>
            <param name="log"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.Void``1(``0)">
            <summary>
            Private empty callback
            </summary>
            <param name="errorMessage"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.SendMessage(System.Byte[],System.Action{EQATEC.Analytics.Monitor.Messaging.SendMessageResult})">
            <summary>
            Send the payload and set result of sending back on the callback
            </summary>
            <param name="payload"></param>
            <param name="sendingResultCallback"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.SendMessage(EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.Message,System.Action{EQATEC.Analytics.Monitor.Messaging.SendMessageResult})">
            <summary>
            Send a message and return the SendResult in the callback
            </summary>
            <param name="message">The message to send</param>
            <param name="callback">The callback</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.RecieveMessage(EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.Message,EQATEC.Analytics.Monitor.Messaging.MessageResponse,System.Action{EQATEC.Analytics.Monitor.Messaging.SendMessageResult})">
            <summary>
            Private method for forwarding and handling the response received from the server once
            the payload has been sent
            </summary>
            <param name="message"></param>
            <param name="response"></param>
            <param name="callback"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.WaitForIdle(System.Int32)">
            <summary>
            Waiting for idle messaging system
            </summary>
            <param name="timeoutMilliSec"></param>
            <returns></returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.Wait(System.Int32)">
            <summary>
            Wait code, platform specific
            </summary>
            <param name="timeout"></param>
            <returns></returns>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.ActiveRequestCount">
            <summary>
            Number of active requests
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Messaging.MessagingSubSystem.Message">
            <summary>
            Simple data carrying class for a message
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.NamespaceDoc">
            <summary>
            The <c>AnalyticsMonitor</c> namespace contains all classes and interfaces needed
            to construct and work with the EQATEC Analytics Monitor
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.NativeMethods">
            <summary>
            Internal class for calling native methods
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Model.Feature">
            <summary>
            Feature registration
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.Feature.SessionHit">
            <summary>
            Number of times this feature has been utilized in the full runtime for this 
            session
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.Feature.ActiveStartTime">
            <summary>
            The start time of this feature when timing a feature
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.Feature.IsActive">
            <summary>
            Is this feature currently active, meaning is it currently being tracked
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Timing">
            <summary>
            Static class for encapsulating all timing related issues in the 
            code. Makes testing for timing related functionality easier to mock out
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Timing.SetSystemTimeCall(EQATEC.Analytics.Monitor.Timing.SystemTimeCall)">
            <summary>
            Explicitly setting the system time call
            </summary>
            <param name="call"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Timing.SetSystemUptimeCall(EQATEC.Analytics.Monitor.Timing.SystemUptimeCall)">
            <summary>
            Explicitly setting the system uptime call
            </summary>
            <param name="call"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Timing.GetWaitHandle">
            <summary>
            Getting a WaitHandle instance in the non-signalled state
            </summary>
            <returns></returns>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Timing.Now">
            <summary>
            Getting the current system time
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Timing.Uptime">
            <summary>
            Getting the current system uptime
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Timing.SystemTimeCall">
            <summary>
            Delegate for getting the current system time
            </summary>
            <returns></returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Timing.SystemUptimeCall">
            <summary>
            Delegate for getting the current system up time
            </summary>
            <returns></returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Timing.WaitHandleCall">
            <summary>
            Delegate for getting a concrete waithandle
            </summary>
            <returns></returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Timing.HiResTimer">
            <summary>
            Pricate class encapsulating platform independent hi-resolution timing (attempting
            to do better than 16ms resolution on the full framework)
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.VoidLog">
            <summary>
            Internal log, default log in the monitor. Allows for testing classes
            to cast the logging interface and hook into the static events
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings">
            <summary>
            Class containing the settings used for constructing the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance. Instances
            are preloaded with default settings which can be adjusted before instance is being passed to 
            the <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(EQATEC.Analytics.Monitor.AnalyticsMonitorSettings)"/> method
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.#ctor(System.String)">
            <summary>
             Construct the default settings corresponding to a given productId.
            </summary>
             <remarks>On the .NET platform the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.Version"/> property is automatically assigned by looking at the
             version of the calling assembly. On other platforms the constructor requires an explicit version parameter</remarks>
            <param name="productId">the id of the product to monitor</param>
            <exception cref="T:System.ArgumentException">returned if product id have the wrong format</exception>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.Version">
            <summary>
            Specifies the version of the software, that should be used for version checking.
            The default value is implicitly retreived of the current application
            by accessing the calling assembly.
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.LoggingInterface">
             <summary>
             The logging interface used for exposing internal messages
             </summary>
             <remarks>You can provide your own implementation of the <see cref="T:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor"/> interface in 
             order to receive the internal logging messages from constructed monitors</remarks>
             <example> This sample shows how to use the logging interface.
             <code>
             class MyClass 
             {
               static void Main() 
               {
                 //Creating AnalyticsMonitorSettings
                 AnalyticsMonitorSettings settings = new AnalyticsMonitorSettings("YOUR_PRODUCT_KEY_HERE");
                 settings.LoggingInterface = new MyLogClass();
             
                 //Creating IAnalyticsMonitor
                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create(settings);
             
                 //Start Analytics monitor
                 monitor.Start();
            
                 /*Your program here....*/
                 
                 //Stop Analytics monitor
                 monitor.Stop();
               }
             }
             class MyLogClass : ILogAnalyticsMonitor
             {
               public void LogMessage(string message)
               {
                 Console.WriteLine("Log: " + message);
               }
             
               public void LogError(string errorMessage)
               {
                 Console.WriteLine("Error: " + errorMessage);
               }
             }
             </code>
             </example>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.Storage">
            <summary>
            The storage interface used internally in the analytics monitor
            for saving and loading state. 
            </summary>
            <remarks>Consider providing your own implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface if
            your application requires special handling when storing data.</remarks>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.StorageSaveInterval">
            <summary>
            The interval with which we autosave the internal statistics. The default
            is one minute. If set to TimeSpan.Zero, no AutoSave is performed
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.ServerUri">
            <summary>
            Override the default uri for the server. For most standard purposes there is no
            need to provide your own uri for the server as the monitor provides a default uri
            which will contact the server correctly
            </summary>
            <remarks>You may require to specify this server uri if the network setup for your
            end users are non-standard. Also be aware that the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.UseSSL"/> property is
            is ignored when explicitly specifying the server uri.</remarks>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.TestMode">
            <summary>
             Use this flag to enable the test mode for this installation.
             This might for example allow you to test version announcements
             before relasing it to customers.
            </summary>
             <remarks>The precise behavior for the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.TestMode"/> property may change over time but
             is provided to explicitly enable certain test scenarios for developers</remarks>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.SynchronizeAutomatically">
            <summary>
             Use this flag to specify is the monitor automatically should synchronize data 
             to the server or it should only synchronize manually on explicit calls to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync"/>.
             The default value is <see langwork="true"/> as the he monitor will automatically synchronize data to the 
             server without the clients have to call <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync"/>.
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.DailyNetworkUtilizationInKB">
            <summary>
            Explicitly set a limit on the daily network utilization of the monitor. The utilization
            is accumulated based on the size of the payload for both upstream and downstream data and 
            is enforce on a daily basis. 
            </summary>
            <remarks>The monitor will not honor a limit lower than 10 kb since the 
            monitor must be able to contact the server with at least a mimimum of payload. If you do not want the monitor to contact the 
            server you should not call <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/> on the monitor instance.</remarks>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.MaxStorageSizeInKB">
            <summary>
            Explicitly set a size limit on the data save to persistent storage by the monitor. The size
            is calculated each time the monitor persists to storage and if the size limit is exceeded it
            will attempt to persist less data. 
            </summary>
            <remarks>The monitor will not honor a limit lower than 1 kb since the monitor requires to
            store at least a minimal amount of metadata</remarks>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.UseSSL">
            <summary>
            Uses https traffic against the servers unless the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.ServerUri"/> has been explicitly
            specified to non-https. By default this property is <see langword="false"/>
            </summary>
            <remarks>If the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.ServerUri"/> property has has been specified explicitly this property
            is ignored. The validation of the certificate from the servers are handled by the underlying
            operating system. For some platforms (such as Windows Mobile 5) this may present a problem since
            they have limited support for wild-card certificates.</remarks>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.ProxyConfig">
            <summary>
            Use this property to explicitly specify the proxy settings for connecting to the server. By default
            there is no proxy configuration and it is picked up from the underlying operating system.
            </summary>
            <remarks>The proxy configuration can be specified in application.config file if prefered.</remarks>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.StatisticsMonitor">
            <summary>
            Class encapsulating the statistics state and the persistance of the state, including
            the auto save
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.StatisticsMonitor.#ctor(EQATEC.Analytics.Monitor.Messaging.IMessageFactory,EQATEC.Analytics.Monitor.Messaging.IMessagingSubSystem,EQATEC.Analytics.Monitor.Storage.IStorageFactory,EQATEC.Analytics.Monitor.IScheduler,EQATEC.Analytics.Monitor.ILogAnalyticsMonitor,EQATEC.Analytics.Monitor.Policy.MonitorPolicy)">
            <summary>
            Constructor
            </summary>
            <param name="messageFactory"></param>
            <param name="messagingSubSystem"></param>
            <param name="storageFactory">the storage factory</param>
            <param name="policy"></param>
            <param name="scheduler"></param>
            <param name="log">the logging interface</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.StatisticsMonitor.StartSession">
            <summary>
            Starting a new session
            </summary>
            <returns>the statistics loaded for this sessions</returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.StatisticsMonitor.EndSession(System.Int32)">
            <summary>
            Ending a session
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.StatisticsMonitor.AddFeature(System.String)">
            <summary>
            Adding a feature
            </summary>
            <param name="featureName">the name of the feature</param>
        </member>
        <member name="E:EQATEC.Analytics.Monitor.StatisticsMonitor.VersionAvailable">
            <summary>
            Event raised when a version check ended
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.OSInfo">
            <summary>
            Class accessing the Operating System information
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.OSInfo.GetOSInfo(EQATEC.Analytics.Monitor.ILogAnalyticsMonitor)">
            <summary>
            Constructor, will collect the OS information
            </summary>
            <param name="log"></param>
            <returns></returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.OSInfoObject">
            <summary>
            Simple data carrying class for OS information
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Model.Statistics">
            <summary>
            Class encapsulating all stored statistics about the application usage
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.Statistics.CreateSnapshot">
            <summary>
            Create a full snapshot of the statistics
            </summary>
            <returns></returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.Statistics.ApplySnapshot(EQATEC.Analytics.Monitor.Model.Statistics)">
            <summary>
            Applying a previous snapshot
            </summary>
            <param name="snapshot"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.Statistics.GetSessionById(System.Guid)">
            <summary>
            Get named session
            </summary>
            <param name="id"></param>
            <returns></returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.Statistics.StartSession(EQATEC.Analytics.Monitor.InstallationSettings,System.Version)">
            <summary>
            Starting a new session
            </summary>
            <param name="installationSettings"></param>
            <param name="applicationVersion"></param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Model.Statistics.EndSession">
            <summary>
            Ending the current session
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.Statistics.Sessions">
            <summary>
            List of sessions, includes the current session and any past sessions
            that have not been sent to the server
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.Statistics.StartCount">
            <summary>
            Incrementing counter for number of times started
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.Statistics.TotalRuntime">
            <summary>
            The total runtime registered on this application
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.Model.Statistics.CurrentSession">
            <summary>
            The current session instance, if any
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Storage.IsolatedStorageAdaptor">
            <summary>
            Storage implementation for the IsolatedStorage
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Storage.IsolatedStorageAdaptor.Save(System.String,System.Byte[])">
            <summary>
            Saves the data to a file specific for the product ID
            </summary>
            <param name="productID">the product ID</param>
            <param name="data">the raw data</param>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Storage.IsolatedStorageAdaptor.Load(System.String)">
            <summary>
            Loads the data associated with the product ID. If no data can be located, returns null
            </summary>
            <param name="productID">the product ID</param>
            <returns>the data for the prouct ID or null if no data can be found</returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Storage.StorageFactory">
            <summary>
            Class encapsulating the loading and saving of data to and from raw bytes
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Storage.StorageFactory.SaveStatistics(EQATEC.Analytics.Monitor.Model.Statistics,EQATEC.Analytics.Monitor.Policy.MonitorPolicy)">
            <summary>
            Saves the statistics
            </summary>
            <param name="statistics">the statistics to save</param>
            <param name="policy">the access info to save</param>
            <returns>the raw data to save or null if unable to convert</returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Storage.StorageFactory.LoadStatistics(EQATEC.Analytics.Monitor.Policy.MonitorPolicy)">
            <summary>
            Loads the statistics and returns the alternativeUri and BlockingData
            </summary>
            <returns>The statistics or null if failed to convert</returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.VersionAvailableEventArgs">
            <summary>
            Event arguments for the version check event typically thrown by <see cref="E:EQATEC.Analytics.Monitor.IAnalyticsMonitor.VersionAvailable"/>
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.VersionAvailableEventArgs.#ctor(System.Version,System.String,System.String,System.Version,System.Boolean,System.DateTime,System.String)">
            <summary>
            Constructor
            </summary>
            <param name="officialVersion">the official version</param>
            <param name="downloadUri">the download uri</param>
            <param name="description">the description of the new version</param>
            <param name="currentVersion">the current version as sent to the server</param>
            <param name="currentVersionDeprecated">whether the current version is deprecated</param>
            <param name="releaseDate">the release date of the official version</param>
            <param name="additionalInformation">additional information returned from the server</param>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.VersionAvailableEventArgs.OfficialVersion">
            <summary>
            Get the version obtained from the server in the version check. 
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.VersionAvailableEventArgs.DownloadUri">
            <summary>
            Get the Uri of the download location obtained from the server in the version check.
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.VersionAvailableEventArgs.VersionDescription">
            <summary>
            Get the description of the newest version as obtained from the server in the version check.
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.VersionAvailableEventArgs.CurrentVersionDeprecated">
            <summary>
            Get the deprecated status of your current version. The current version is considered
            deprecated if it is mathcing a version marked as deprecated on the server
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.VersionAvailableEventArgs.ReleaseDate">
            <summary>
            Get the release date of the official version
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.VersionAvailableEventArgs.CurrentVersion">
            <summary>
            The current version as specified in the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings">AnalyticsMonitorSettings</see> object
            used for initialization of the monitor instance
            </summary>
        </member>
        <member name="P:EQATEC.Analytics.Monitor.VersionAvailableEventArgs.AdditionalInfo">
            <summary>
            Additional information passed to the client along with the version information. Can be
            used to send custom formatted information from server to clients
            </summary>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Guard">
            <summary>
            Internal class making ArgumentNull checks a little easier
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Guard.IsNotNull``1(``0,System.String)">
            <summary>
            Checks that argument is not null and returns it
            </summary>
            <typeparam name="T"></typeparam>
            <param name="input"></param>
            <param name="argumentName"></param>
            <returns></returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.XmlUtil">
            <summary>
            internal class for doing some Xml manipulation
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.XmlUtil.WriteStartElement(System.Xml.XmlWriter,System.String,System.String[])">
            <summary>
            Adding a named XmlElement as a child to a XmlNode
            </summary>
            <param name="xtw"></param>
            <param name="elementName"></param>
            <param name="attrs"></param>
            <returns></returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Parser">
            <summary>
            Internal class for non throwing parsing
            </summary>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.Parser.TryParseUint(System.String,System.UInt32@)">
            <summary>
            Special parsing of int to support both full and CF framework
            </summary>
            <param name="input"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:EQATEC.Analytics.Monitor.StringUtil.Chop(System.String,System.Int32)">
            <summary>
            Chop the string to a given length
            </summary>
            <param name="input"></param>
            <param name="length"></param>
            <returns></returns>
        </member>
        <member name="T:EQATEC.Analytics.Monitor.Storage.VoidStorage">
            <summary>
            Empty storage, mainly for having an internal default and avoid
            excessive null-checks
            </summary>
        </member>
    </members>
</doc>
